tarsec 0.2.1 → 0.3.0

package/README.md

@@ -48,7 +48,7 @@ parser("hello there"); // failure
 - [Pretty error messages](/tutorials/pretty-errors.md)
 
 ## Examples
-- [A markdown parser](/tests/examples/markdown.ts)
+- [A CommonMark-ish markdown parser](/lib/parsers/markdown) — importable as `tarsec/parsers/markdown`. Supports headings (ATX 1–6 with optional trailing `#` stripping, plus setext), fenced and indented code blocks, multi-backtick inline code spans, multi-line / nested block quotes, ordered / unordered / nested lists, pipe tables with alignment, horizontal rules, HTML passthrough, VitePress-style YAML frontmatter, plus inline bold/italic (`*` and `_`), combined `***bold-italic***`, strikethrough, escapes, autolinks, hard *and* soft line breaks, images and links with optional `"title"`, and reference-style links / footnotes resolved in a post-parse pass. Paragraphs round-trip soft-wrapped lines through an `inline-soft-break` node. Inline emphasis, strike, and link content all nest, so ``**[link](u)**`` and ``*a `code` b*`` round-trip into the AST.
 
 Read more about [use cases for tarsec](/tutorials/use-case.md).
 

package/dist/parsers/markdown/blocks.d.ts

@@ -0,0 +1,14 @@
+import { Parser } from "../../types.js";
+import { Heading, CodeBlock, BlockQuote, Paragraph, HorizontalRule, List, Table, HTMLBlock } from "./types.js";
+export { imageParser } from "./inline.js";
+export declare const headingParser: Parser<Heading>;
+export declare const codeBlockParser: Parser<CodeBlock>;
+export declare const blockQuoteParser: Parser<BlockQuote>;
+export declare const indentedCodeBlockParser: Parser<CodeBlock>;
+export declare const setextHeadingParser: Parser<Heading>;
+export declare const listParser: Parser<List>;
+export declare const blankLine: Parser<unknown>;
+export declare const htmlBlockParser: Parser<HTMLBlock>;
+export declare const tableParser: Parser<Table>;
+export declare const horizontalRuleParser: Parser<HorizontalRule>;
+export declare const paragraphParser: Parser<Paragraph>;

package/dist/parsers/markdown/blocks.js

@@ -0,0 +1,189 @@
+import { seqC, seqR, capture, optional, or, manyTillStr, many1Till, exactly, many, many1, many1WithJoin, map, not, lazy, } from "../../combinators.js";
+import { str, spaces, char, eof, set, alphanum, oneOf, noneOf, } from "../../parsers.js";
+import { digit, letter } from "../../parsers.js";
+import { manyTill } from "../../combinators.js";
+import { inlineMarkdownParser, softBreakParser } from "./inline.js";
+export { imageParser } from "./inline.js";
+const languageChar = or(alphanum, oneOf("_+#.-"));
+const languageTag = many1WithJoin(languageChar);
+/* ATX heading marker: 1–6 consecutive `#`, not followed by another `#`.
+ * Try widest first so `###` doesn't parse as level 1 and leave `##` behind.
+ * `not(char("#"))` rejects 7+ `#` runs (they fall through to a paragraph). */
+const atxMarker = or(...[6, 5, 4, 3, 2, 1].map((n) => map(seqR(exactly(n, char("#")), not(char("#"))), () => n)));
+/* An optional trailing run of `#`s on an ATX heading: at least one separating
+ * space, one or more `#`, optional trailing spaces, then end-of-line. */
+const trailingHashRun = seqR(many1(char(" ")), many1(char("#")), many(char(" ")), or(char("\n"), eof));
+/* The heading body — everything up to (but not including) either the line end
+ * or a trailing `#` run. We capture this as a raw string then re-parse it as
+ * inline markdown so the body shape matches ATX/setext headings. */
+const headingBody = many1Till(or(char("\n"), trailingHashRun));
+export const headingParser = map(seqC(capture(atxMarker, "level"), spaces, capture(headingBody, "body"), optional(trailingHashRun), optional(char("\n"))), ({ level, body }) => {
+    const inner = many1(inlineMarkdownParser)(body);
+    return {
+        type: "heading",
+        level: level,
+        content: inner.success
+            ? inner.result
+            : [{ type: "inline-text", content: body }],
+    };
+});
+export const codeBlockParser = seqC(set("type", "code-block"), str("```"), capture(optional(languageTag), "language"), optional(spaces), capture(manyTillStr("```"), "content"), str("```"));
+/* Multi-line and nested block quotes.
+ *
+ *  - Consume consecutive lines beginning with "> " (the space is optional).
+ *  - Join their stripped content with newlines.
+ *  - Recursively re-parse the inner text: a sub-blockquote OR inline markdown.
+ *
+ *  `lazy` defers the self-reference so we can recurse for nesting. */
+const blockQuoteLine = map(seqC(char(">"), optional(char(" ")), capture(manyTillStr("\n"), "line"), or(char("\n"), eof)), ({ line }) => line);
+// Inside the joined inner text, accept either a nested blockquote (possibly
+// after a leading newline), a soft newline between lines, or any inline node.
+const softNewline = map(char("\n"), () => ({ type: "inline-text", content: " " }));
+const nestedBlockQuote = lazy(() => map(seqC(many(char("\n")), capture(blockQuoteParser, "quote")), ({ quote }) => quote));
+const blockQuoteContent = or(nestedBlockQuote, softNewline, inlineMarkdownParser);
+// Re-parse the joined inner text as a sequence of blockquote-content nodes.
+// (We have to round-trip through a string because the `>` prefixes need to be
+//  stripped before nested blockquotes can be recognised.)
+const reparseInner = (innerText) => {
+    const inner = many1(blockQuoteContent)(innerText);
+    return inner.success ? inner.result : [];
+};
+export const blockQuoteParser = map(many1(blockQuoteLine), (lines) => ({
+    type: "block-quote",
+    content: reparseInner(lines.join("\n")),
+}));
+/* Indented code block: one or more consecutive lines beginning with 4 spaces
+ * or a tab. The indent is stripped from each line. */
+const indentPrefix = or(str("    "), char("\t"));
+const indentedLine = map(seqC(indentPrefix, capture(manyTillStr("\n"), "line"), or(char("\n"), eof)), ({ line }) => line + "\n");
+const indentedLines = map(many1(indentedLine), (lines) => lines.join(""));
+export const indentedCodeBlockParser = seqC(set("type", "code-block"), set("language", null), capture(indentedLines, "content"));
+/* Setext-style headings: a line of content followed by an underline of `=`
+ * (level 1) or `-` (level 2), terminated by `\n` or end-of-input. We capture
+ * the first line as a raw string, then re-parse it as inline markdown so the
+ * heading's content has the same shape as ATX headings. */
+const setextLine = many1WithJoin(noneOf("\n"));
+const setextH1Underline = map(many1(char("=")), () => 1);
+const setextH2Underline = map(many1(char("-")), () => 2);
+const _setextRaw = seqC(set("type", "heading"), capture(setextLine, "content"), char("\n"), capture(or(setextH1Underline, setextH2Underline), "level"), or(char("\n"), eof));
+export const setextHeadingParser = map(_setextRaw, (caps) => {
+    const inner = many1(inlineMarkdownParser)(caps.content);
+    return {
+        type: "heading",
+        level: caps.level,
+        content: inner.success
+            ? inner.result
+            : [{ type: "inline-text", content: caps.content }],
+    };
+});
+const unorderedMarker = map(oneOf("-*+"), () => ({ ord: false, start: 1 }));
+const orderedMarker = map(seqC(capture(many1WithJoin(digit), "digits"), char(".")), ({ digits }) => ({ ord: true, start: parseInt(digits, 10) }));
+const indentOf = (n) => n > 0 ? str(" ".repeat(n)) : str("");
+/* GFM task-list checkbox: `[ ]` (unchecked), `[x]` or `[X]` (checked).
+ * Must be followed by a single space (consumed) to count as a checkbox. */
+const taskCheckbox = map(seqC(char("["), capture(or(char(" "), char("x"), char("X")), "mark"), str("] ")), ({ mark }) => mark !== " ");
+const itemHeadOf = (indent, markerParser) => map(seqC(indentOf(indent), capture(markerParser, "marker"), char(" "), capture(optional(taskCheckbox), "checked"), capture(manyTillStr("\n"), "line"), or(char("\n"), eof)), ({ marker, checked, line }) => {
+    const raw = { marker, line };
+    if (checked !== null)
+        raw.checked = checked;
+    return raw;
+});
+const parseInline = (line) => {
+    const inline = many1(inlineMarkdownParser)(line);
+    return inline.success ? inline.result : [];
+};
+// One list item: an item-head followed by an optional sublist at +2 indent.
+const itemWithSublist = (indent, markerParser) => map(seqC(capture(itemHeadOf(indent, markerParser), "raw"), capture(optional(lazy(() => listParserAt(indent + 2))), "sublist")), ({ raw, sublist }) => {
+    const item = { content: parseInline(raw.line) };
+    if (sublist)
+        item.sublist = sublist;
+    if (raw.checked !== undefined)
+        item.checked = raw.checked;
+    return { marker: raw.marker, item };
+});
+// A list of one or more items that all share a marker family.
+const listOf = (indent, markerParser) => map(seqC(capture(itemWithSublist(indent, markerParser), "first"), capture(many(itemWithSublist(indent, markerParser)), "rest")), ({ first, rest }) => ({
+    type: "list",
+    ordered: first.marker.ord,
+    start: first.marker.start,
+    items: [first.item, ...rest.map((r) => r.item)],
+}));
+const listParserAt = (indent) => or(listOf(indent, unorderedMarker), listOf(indent, orderedMarker));
+export const listParser = listParserAt(0);
+/* Tables.
+ *
+ * Pipe-delimited GFM-style. A table is:
+ *
+ *   | h1 | h2 |     ← header row
+ *   |----|:--:|     ← separator row, with alignment markers
+ *   | a  | b  |     ← one or more data rows
+ *
+ * Each cell is `noneOf("|\n")`. We `map` the captured content to `.trim()`
+ * so headers/rows aren't padded with spaces. */
+const cellContent = map(many1WithJoin(noneOf("|\n")), (s) => s.trim());
+const cellThenBar = map(seqC(capture(cellContent, "cell"), char("|")), ({ cell }) => cell);
+const tableRow = map(seqC(char("|"), capture(many1(cellThenBar), "cells"), or(char("\n"), eof)), ({ cells }) => cells);
+const sepCell = map(seqC(many(char(" ")), capture(optional(char(":")), "left"), many1(char("-")), capture(optional(char(":")), "right"), many(char(" "))), ({ left, right }) => {
+    const leftColon = left !== null;
+    const rightColon = right !== null;
+    if (leftColon && rightColon)
+        return "center";
+    if (rightColon)
+        return "right";
+    if (leftColon)
+        return "left";
+    return null;
+});
+const sepCellThenBar = map(seqC(capture(sepCell, "cell"), char("|")), ({ cell }) => cell);
+const sepRow = map(seqC(char("|"), capture(many1(sepCellThenBar), "cells"), or(char("\n"), eof)), ({ cells }) => cells);
+/* HTML blocks (passthrough subset).
+ *
+ * A line starting with `<` followed by a letter, `/`, `!`, or `?` is treated
+ * as the start of a raw HTML block. The block extends until the next blank
+ * line or end of input. We don't try to balance tags — the content is kept
+ * as a single opaque string so downstream renderers can hand it to an HTML
+ * renderer untouched. */
+const htmlBlockOpen = seqR(char("<"), or(letter, oneOf("/!?")));
+// "\n" followed by zero or more spaces/tabs followed by another "\n" or end of input.
+export const blankLine = seqR(char("\n"), many(oneOf(" \t")), or(char("\n"), eof));
+// Peek at the opening (`not(not(...))` is a non-consuming lookahead), then
+// consume everything up to the next blank line or eof.
+export const htmlBlockParser = seqC(set("type", "html-block"), not(not(htmlBlockOpen)), capture(manyTill(or(blankLine, eof)), "content"));
+export const tableParser = seqC(set("type", "table"), capture(tableRow, "headers"), capture(sepRow, "alignments"), capture(many1(tableRow), "rows"));
+/* Horizontal rules:  three-or-more of the same `-`, `*`, or `_`,
+ * with optional spaces between, ending in newline or eof. The "three or
+ * more" rule is expressed structurally — three explicit `char(c)`s followed
+ * by `many` more — so no count-and-validate wrapper is needed. */
+const hrSpaces = many(char(" "));
+const hrOf = (c) => map(seqR(hrSpaces, char(c), hrSpaces, char(c), hrSpaces, char(c), hrSpaces, many(seqR(char(c), hrSpaces)), or(char("\n"), eof)), () => ({ type: "horizontal-rule" }));
+export const horizontalRuleParser = or(hrOf("-"), hrOf("*"), hrOf("_"));
+// "\n" followed by zero or more spaces/tabs followed by another "\n" or end of input.
+// (`blankLine` is declared near `htmlBlockParser` above, since both need it at
+//  module-eval time.)
+/* Block-level constructs that, if they would start at the *current* line
+ * position, must interrupt a soft-wrapped paragraph instead of being eaten
+ * as inline content. Setext is intentionally excluded — its underline is
+ * resolved by `setextHeadingParser` running ahead of `paragraphParser` in
+ * the top-level dispatch. */
+const blockInterrupt = or(
+// ATX heading (1–6 `#` then a space)
+seqR(atxMarker, char(" ")), 
+// Block quote
+char(">"), 
+// Fenced code block
+str("```"), 
+// Horizontal rule (3+ of -, *, or _ with optional intervening spaces)
+horizontalRuleParser, 
+// List marker (unordered or `<digits>.`) followed by a space
+seqR(or(oneOf("-*+"), seqR(many1(digit), char("."))), char(" ")), 
+// Table row
+char("|"), 
+// HTML block opener
+seqR(char("<"), or(letter, oneOf("/!?"))));
+/* A paragraph node: an inline node OR a soft line break (single `\n` that
+ * isn't the start of a blank line *and* doesn't precede a block opener).
+ * Hard breaks ("  \n" / "\\\n") win over soft breaks because they're
+ * matched earlier inside `inlineMarkdownParser`'s `or`. */
+const paragraphSoftBreak = map(seqR(softBreakParser, not(blockInterrupt)), () => ({ type: "inline-soft-break" }));
+const paragraphInline = map(seqC(not(blankLine), capture(or(paragraphSoftBreak, inlineMarkdownParser), "node")), ({ node }) => node);
+export const paragraphParser = map(many1(paragraphInline), (content) => ({ type: "paragraph", content: content }));

package/dist/parsers/markdown/frontmatter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * YAML frontmatter parser for the Markdown example.
+ *
+ * Supports the spec from https://vitepress.dev/guide/frontmatter:
+ *   ---
+ *   title: Docs with VitePress
+ *   editLink: true
+ *   ---
+ *
+ * YAML coverage is a useful subset (top-level `key: value` only), built from
+ * Tarsec combinators per the project's "combinator-first" rule:
+ *   - scalar values: bare strings, single/double-quoted strings, integers,
+ *     floats, `true`/`false`, `null`/`~`
+ *   - inline flow lists:  [a, b, "c d"]
+ */
+import { Parser } from "../../types.js";
+import { Frontmatter } from "./types.js";
+/**
+ * VitePress-style YAML frontmatter: a `---`-delimited block at the very top
+ * of a Markdown file.
+ */
+export declare const frontmatterParser: Parser<Frontmatter>;

package/dist/parsers/markdown/frontmatter.js

@@ -0,0 +1,80 @@
+/**
+ * YAML frontmatter parser for the Markdown example.
+ *
+ * Supports the spec from https://vitepress.dev/guide/frontmatter:
+ *   ---
+ *   title: Docs with VitePress
+ *   editLink: true
+ *   ---
+ *
+ * YAML coverage is a useful subset (top-level `key: value` only), built from
+ * Tarsec combinators per the project's "combinator-first" rule:
+ *   - scalar values: bare strings, single/double-quoted strings, integers,
+ *     floats, `true`/`false`, `null`/`~`
+ *   - inline flow lists:  [a, b, "c d"]
+ */
+import { capture, many, many1WithJoin, map, optional, or, seqC, seqR, sepBy, } from "../../combinators.js";
+import { alphanum, char, eof, noneOf, oneOf, quotedString, str, } from "../../parsers.js";
+// --- helpers -----------------------------------------------------------------
+const hSpace = oneOf(" \t");
+const hSpaces = many(hSpace);
+const newlineOrEof = or(char("\n"), eof);
+/** Strip the surrounding quote chars (`'`, `"`, or `` ` ``) added by `quotedString`. */
+const stripQuotes = (s) => s.slice(1, -1);
+/**
+ * Classify a trimmed bare scalar token into its YAML value.
+ * Booleans and null are matched exactly; otherwise we try numeric, else fall
+ * back to the raw string.
+ */
+function classifyBare(raw) {
+    const s = raw.trim();
+    if (s === "true")
+        return true;
+    if (s === "false")
+        return false;
+    if (s === "null" || s === "~")
+        return null;
+    if (s.length > 0) {
+        const n = Number(s);
+        if (!Number.isNaN(n) && Number.isFinite(n))
+            return n;
+    }
+    return s;
+}
+// --- key ---------------------------------------------------------------------
+// Conservative key chars: letters, digits, underscore, hyphen.
+const keyChar = or(alphanum, oneOf("_-"));
+const yamlKey = many1WithJoin(keyChar);
+// --- scalar values -----------------------------------------------------------
+// Quoted scalar — returns the inner string (quotes stripped).
+const quotedScalar = map(quotedString, stripQuotes);
+// Bare scalar in top-level context: runs to end-of-line.
+const bareValueLine = map(many1WithJoin(noneOf("\n")), classifyBare);
+// Bare scalar inside a flow list `[...]`: ends at `,` or `]` (or `\n`).
+const bareValueInList = map(many1WithJoin(noneOf(",]\n")), classifyBare);
+// One element of a flow list: optional leading whitespace, then quoted or bare.
+const listElement = map(seqC(hSpaces, capture(or(quotedScalar, bareValueInList), "value")), ({ value }) => value);
+// Inline flow list: `[a, b, "c d"]`
+const flowList = map(seqC(char("["), capture(sepBy(char(","), listElement), "items"), hSpaces, char("]")), ({ items }) => items);
+// Any value: prefer flow list, then quoted, then bare.
+const yamlValue = or(flowList, quotedScalar, bareValueLine);
+// --- entries / body ----------------------------------------------------------
+// `key: value` — gap between `:` and value may include horizontal whitespace.
+const yamlEntry = map(seqC(capture(yamlKey, "key"), char(":"), hSpaces, capture(yamlValue, "value")), ({ key, value }) => [key, value]);
+// One terminated entry: `key: value\n` (or eof-terminated).
+const entryLine = map(seqC(capture(yamlEntry, "entry"), newlineOrEof), ({ entry }) => entry);
+const yamlBody = many(entryLine);
+// --- frontmatter -------------------------------------------------------------
+const fence = str("---");
+const fenceLine = seqR(fence, optional(hSpaces), char("\n"));
+const closingFence = seqR(fence, optional(hSpaces), newlineOrEof);
+/**
+ * VitePress-style YAML frontmatter: a `---`-delimited block at the very top
+ * of a Markdown file.
+ */
+export const frontmatterParser = map(seqC(fenceLine, capture(yamlBody, "entries"), closingFence), ({ entries }) => {
+    const data = {};
+    for (const [k, v] of entries)
+        data[k] = v;
+    return { type: "frontmatter", data };
+});

package/dist/parsers/markdown/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./inline.js";
+export * from "./blocks.js";
+export * from "./references.js";
+export * from "./frontmatter.js";
+import { Parser } from "../../types.js";
+export declare const markdownParser: Parser<unknown[]>;

package/dist/parsers/markdown/index.js

@@ -0,0 +1,27 @@
+export * from "./types.js";
+export * from "./inline.js";
+export * from "./blocks.js";
+export * from "./references.js";
+export * from "./frontmatter.js";
+import { seq, sepBy, or, optional, many1, map } from "../../combinators.js";
+import { spaces, newline } from "../../parsers.js";
+import { headingParser, codeBlockParser, blockQuoteParser, paragraphParser, imageParser, horizontalRuleParser, setextHeadingParser, indentedCodeBlockParser, listParser, tableParser, htmlBlockParser, } from "./blocks.js";
+import { linkDefinitionParser, footnoteDefinitionParser, resolveReferences, } from "./references.js";
+import { frontmatterParser } from "./frontmatter.js";
+// Block separator: one or more newlines (with optional trailing horizontal
+// whitespace). Crucially this does NOT consume leading indentation on the
+// next block — so a 4-space indented code block isn't dewhitespaced before
+// indentedCodeBlockParser ever sees it.
+const blockSeparator = many1(newline);
+const _markdownParser = seq([
+    optional(frontmatterParser),
+    optional(spaces),
+    sepBy(blockSeparator, or(setextHeadingParser, horizontalRuleParser, headingParser, codeBlockParser, indentedCodeBlockParser, tableParser, blockQuoteParser, listParser, htmlBlockParser, linkDefinitionParser, footnoteDefinitionParser, paragraphParser, imageParser)),
+    optional(spaces),
+], (r) => {
+    const fm = r[0];
+    const blocks = r[2];
+    return fm ? [fm, ...blocks] : blocks;
+});
+// Resolve [id]: url definitions across the AST after parsing.
+export const markdownParser = map(_markdownParser, (nodes) => resolveReferences(nodes));

package/dist/parsers/markdown/inline.d.ts

@@ -0,0 +1,48 @@
+import { Parser } from "../../types.js";
+import { InlineMarkdown, InlineText, InlineBold, InlineItalic, InlineBoldItalic, InlineStrike, InlineHardBreak, InlineSoftBreak, InlineLink, InlineCode, Image, InlineRefLink, InlineRefImage, InlineFootnoteRef, InlineHTML } from "./types.js";
+export declare const inlineTextParser: Parser<InlineText>;
+/**
+ * Run `inlineMarkdownParser` repeatedly until `stop` would match at the
+ * current position. The `stop` parser is a lookahead — it is *not* consumed.
+ * Returns the list of inline nodes collected before `stop`.
+ *
+ * Used by every delimited inline parser (bold, italic, strike, link, …) so
+ * that the content between delimiters is a sequence of inline nodes rather
+ * than a flat string.
+ */
+export declare const inlineSeqUntil: (stop: Parser<unknown>) => Parser<InlineMarkdown[]>;
+export declare const inlineBoldParser: Parser<InlineBold>;
+export declare const inlineItalicParser: Parser<InlineItalic>;
+export declare const inlineLinkParser: Parser<InlineLink>;
+export declare const inlineCodeParser: Parser<InlineCode>;
+export declare const inlineEscapeParser: Parser<InlineText>;
+export declare const inlineBoldItalicParser: Parser<InlineBoldItalic>;
+export declare const inlineBoldUnderscoreParser: Parser<InlineBold>;
+export declare const inlineItalicUnderscoreParser: Parser<InlineItalic>;
+export declare const urlAutolinkParser: Parser<InlineLink>;
+export declare const emailAutolinkParser: Parser<InlineLink>;
+export declare const autolinkParser: Parser<InlineLink>;
+export declare const bareUrlAutolinkParser: Parser<InlineLink>;
+export declare const htmlOpenTagParser: Parser<InlineHTML>;
+export declare const htmlCloseTagParser: Parser<InlineHTML>;
+export declare const htmlCommentParser: Parser<InlineHTML>;
+export declare const htmlInlineParser: Parser<InlineHTML>;
+export declare const inlineFootnoteRefParser: Parser<InlineFootnoteRef>;
+export declare const inlineRefLinkParser: Parser<InlineRefLink>;
+export declare const inlineRefImageParser: Parser<InlineRefImage>;
+/** An inline image: ![alt](url) or ![alt](url "title"). Lives in `inline.ts`
+ *  so it can participate in paragraph parsing without `blocks.ts` becoming a
+ *  circular dep. */
+export declare const imageParser: Parser<Image>;
+export declare const hardBreakParser: Parser<InlineHardBreak>;
+/** A single `\n` that is *not* part of a blank line (which would terminate the
+ *  enclosing paragraph). Hard breaks are matched earlier in `inlineMarkdownParser`'s
+ *  `or` so a "  \n" stays a hard break, never a soft one. */
+export declare const softBreakParser: Parser<InlineSoftBreak>;
+export declare const inlineStrikeParser: Parser<InlineStrike>;
+export declare const htmlEntityParser: Parser<InlineText>;
+/** Last-resort: consume a single delimiter char as literal text so unmatched
+ *  delimiters (e.g. the `_` in snake_case_word, or a stray `*`) don't crash
+ *  the paragraph. Matches one of the inline-text stop characters. */
+export declare const inlineLiteralCharParser: Parser<InlineText>;
+export declare const inlineMarkdownParser: Parser<InlineMarkdown>;

package/dist/parsers/markdown/inline.js

@@ -0,0 +1,249 @@
+import { seqC, seqR, capture, captureCaptures, or, not, map, many, many1, many1Till, many1WithJoin, manyWithJoin, manyTillStr, iManyTillStr, count, exactly, lazy, } from "../../combinators.js";
+import { str, char, eof, set, oneOf, alphanum, noneOf, digit, letter, anyChar } from "../../parsers.js";
+import { success, failure } from "../../types.js";
+import { optional, between } from "../../combinators.js";
+// Stop inline-text at any single delimiter char OR at a hard-break sequence
+// ("  \n"+). Using many1Till with an `or` of delimiters makes the stop set
+// composable rather than embedded inside a regex. `]` is included so that
+// inline-text inside a link-text (`[...]`) terminates at the closing `]`.
+const inlineTextStop = or(oneOf("*_`[]!<~\\&\n"), str("  "));
+export const inlineTextParser = map(many1Till(inlineTextStop), (content) => ({ type: "inline-text", content }));
+/**
+ * Run `inlineMarkdownParser` repeatedly until `stop` would match at the
+ * current position. The `stop` parser is a lookahead — it is *not* consumed.
+ * Returns the list of inline nodes collected before `stop`.
+ *
+ * Used by every delimited inline parser (bold, italic, strike, link, …) so
+ * that the content between delimiters is a sequence of inline nodes rather
+ * than a flat string.
+ */
+export const inlineSeqUntil = (stop) => many(map(seqC(not(stop), capture(lazy(() => inlineMarkdownParser), "node")), ({ node }) => node));
+export const inlineBoldParser = map(seqC(str("**"), capture(inlineSeqUntil(str("**")), "content"), str("**")), ({ content }) => ({ type: "inline-bold", content: content }));
+export const inlineItalicParser = map(seqC(not(str("**")), char("*"), capture(inlineSeqUntil(char("*")), "content"), char("*")), ({ content }) => ({ type: "inline-italic", content: content }));
+/* URL + optional title used by both inline-link and inline-image parsers.
+ * `urlToken` is whitespace- and `)`-terminated. Empty destinations (`[a]()`)
+ * are allowed via `manyWithJoin` (zero-or-more). `titleClause` is an
+ * optional leading-space-separated `"..."` or `'...'`. Both are pure
+ * combinator-based so the link/image parsers can share them. */
+const urlToken = manyWithJoin(noneOf(" \t\n)"));
+const titleClause = map(seqC(many1(char(" ")), captureCaptures(or(seqC(char('"'), capture(manyTillStr('"'), "title"), char('"')), seqC(char("'"), capture(manyTillStr("'"), "title"), char("'"))))), ({ title }) => title);
+export const inlineLinkParser = map(seqC(char("["), capture(inlineSeqUntil(char("]")), "content"), str("]("), capture(urlToken, "url"), capture(optional(titleClause), "title"), char(")")), ({ content, url, title }) => {
+    const link = {
+        type: "inline-link",
+        content: content,
+        url,
+    };
+    if (title != null)
+        link.title = title;
+    return link;
+});
+/* Multi-backtick code spans.
+ *
+ *   `foo`            → "foo"
+ *   ``a`b``          → "a`b"       (close on exactly N backticks)
+ *   `` foo ``        → "foo"       (strip one space on each side when both)
+ *   `   `            → "   "       (don't strip if content is all spaces)
+ *
+ * The opener is a run of N backticks; the closer is another run of *exactly*
+ * N backticks. Body atoms are either a single non-tick char or a tick run
+ * whose length is *not* N (so it can't be misread as the closer). The opener
+ * count threads into the closer via a small wrapper — every other piece is
+ * combinator-shaped. */
+const tickRun = count(char("`"));
+const tickRunOf = (n) => seqR(exactly(n, char("`")), or(not(char("`")), eof));
+const codeBodyAtom = (n) => or(noneOf("`"), map(seqR(not(tickRunOf(n)), many1(char("`"))), (parts) => parts[1].join("")));
+const codeBody = (n) => manyWithJoin(codeBodyAtom(n));
+const stripCodeSpan = (s) => s.length >= 2 && s.startsWith(" ") && s.endsWith(" ") && s.trim().length > 0
+    ? s.slice(1, -1)
+    : s;
+export const inlineCodeParser = (input) => {
+    const opened = tickRun(input);
+    if (!opened.success)
+        return opened;
+    const n = opened.result;
+    const closed = map(seqR(codeBody(n), tickRunOf(n)), (parts) => stripCodeSpan(parts[0]))(opened.rest);
+    if (!closed.success) {
+        return failure("unmatched code span fence", input);
+    }
+    return success({ type: "inline-code", content: closed.result }, closed.rest);
+};
+const ESCAPABLE = "\\`*_{}[]()#+-.!~<>|";
+export const inlineEscapeParser = seqC(set("type", "inline-text"), char("\\"), capture(oneOf(ESCAPABLE), "content"));
+export const inlineBoldItalicParser = or(map(seqC(str("***"), capture(inlineSeqUntil(str("***")), "content"), str("***")), ({ content }) => ({
+    type: "inline-bold-italic",
+    content: content,
+})), map(seqC(str("___"), capture(inlineSeqUntil(str("___")), "content"), str("___")), ({ content }) => ({
+    type: "inline-bold-italic",
+    content: content,
+})));
+export const inlineBoldUnderscoreParser = map(seqC(str("__"), capture(inlineSeqUntil(str("__")), "content"), str("__"), not(alphanum)), ({ content }) => ({ type: "inline-bold", content: content }));
+export const inlineItalicUnderscoreParser = map(seqC(not(str("__")), char("_"), capture(inlineSeqUntil(char("_")), "content"), char("_"), not(alphanum)), ({ content }) => ({ type: "inline-italic", content: content }));
+// URL body inside <...>: http(s)://<non-space, non-< or >>
+const urlBody = map(seqR(str("http"), or(str("s"), str("")), str("://"), many1WithJoin(noneOf(" \t\n<>"))), (parts) => parts.join(""));
+// Email body: local@domain.tld — no spaces, no < > or duplicates of @ inside parts
+const emailPart = many1WithJoin(noneOf(" \t\n<>@."));
+const emailBody = map(seqR(emailPart, char("@"), emailPart, char("."), emailPart), (parts) => parts.join(""));
+// Wrap a literal string as the single-text content array used by InlineLink.
+const asTextContent = (s) => [
+    { type: "inline-text", content: s },
+];
+export const urlAutolinkParser = map(seqC(char("<"), capture(urlBody, "url"), char(">")), ({ url }) => ({ type: "inline-link", content: asTextContent(url), url }));
+export const emailAutolinkParser = map(seqC(char("<"), capture(emailBody, "email"), char(">")), ({ email }) => ({
+    type: "inline-link",
+    content: asTextContent(email),
+    url: `mailto:${email}`,
+}));
+export const autolinkParser = or(urlAutolinkParser, emailAutolinkParser);
+/* Bare-URL GFM autolinks: `http(s)://…` without surrounding `<>`. The body
+ * is built from three kinds of atom so the punctuation/paren-balance rules
+ * fall out of combinator composition:
+ *   - `bareUrlParenGroup` — a balanced `(...)` (recursive via `lazy`), so
+ *     Wikipedia-style URLs like `…Lisp_(programming_language)` keep their
+ *     parens and an unmatched trailing `)` falls through to the surrounding
+ *     text;
+ *   - `bareUrlPunctMidway` — one of `.,!?;:` accepted *only* when at least
+ *     one non-punct atom follows, so trailing sentence punctuation stays
+ *     in the surrounding text (a `not(...)` lookahead does the work);
+ *   - `bareUrlNormalChar` — any other URL char.
+ *
+ * `urlBodyStop` is the lookahead set that ends a URL outside a paren group:
+ * whitespace, `<`, `>`, `)`, or end-of-input. */
+const bareUrlScheme = map(seqC(capture(str("http"), "scheme"), capture(optional(char("s")), "s"), str("://")), ({ scheme, s }) => scheme + (s !== null && s !== void 0 ? s : "") + "://");
+const urlBodyStop = or(oneOf(" \t\n<>)"), eof);
+const urlTrailingPunct = oneOf(".,!?;:");
+const bareUrlNormalChar = noneOf(" \t\n<>().,!?;:");
+const bareUrlPunctMidway = map(seqC(capture(urlTrailingPunct, "p"), 
+// Reject if the remainder is just more punct then a URL stop — that
+// would mean this `.` (or `,`/`!`/etc) is part of a trailing run.
+not(seqR(many(urlTrailingPunct), urlBodyStop))), ({ p }) => p);
+const bareUrlAtom = lazy(() => or(bareUrlParenGroup, bareUrlPunctMidway, bareUrlNormalChar));
+const bareUrlParenGroup = map(seqC(capture(char("("), "open"), capture(manyWithJoin(bareUrlAtom), "inner"), capture(char(")"), "close")), ({ open, inner, close }) => open + inner + close);
+const bareUrlBody = many1WithJoin(bareUrlAtom);
+export const bareUrlAutolinkParser = map(seqC(capture(bareUrlScheme, "scheme"), capture(bareUrlBody, "body")), ({ scheme, body }) => {
+    const url = scheme + body;
+    return {
+        type: "inline-link",
+        content: [{ type: "inline-text", content: url }],
+        url,
+    };
+});
+/* Inline HTML passthrough.
+ *
+ * Three CommonMark shapes are supported (each in its own exported parser):
+ *   - open / self-closing tags: `<a>`, `<a href="x">`, `<br/>`,
+ *   - close tags: `</a>`, `</a   >`,
+ *   - comments: `<!-- … -->`.
+ *
+ * The output is always an `InlineHTML` node whose `content` is the raw source
+ * (including the angle brackets), so downstream renderers pass it through
+ * untouched. We do not try to balance opens/closes or sanitise anything.
+ *
+ * The pieces below are shared helpers: `htmlTagName`, `htmlAttribute`,
+ * `htmlAttributes`, `htmlWS`. All built from combinators with named
+ * captures so the reconstructed string mirrors the source exactly. */
+const htmlWS = manyWithJoin(oneOf(" \t\n"));
+const htmlWS1 = many1WithJoin(oneOf(" \t\n"));
+const htmlTagName = map(seqC(capture(letter, "first"), capture(manyWithJoin(or(alphanum, char("-"))), "rest")), ({ first, rest }) => first + rest);
+const htmlAttrName = map(seqC(capture(or(letter, char("_"), char(":")), "first"), capture(manyWithJoin(or(alphanum, oneOf("_:.-"))), "rest")), ({ first, rest }) => first + rest);
+const dqAttrValue = map(seqC(char('"'), capture(manyTillStr('"'), "v"), char('"')), ({ v }) => `"${v}"`);
+const sqAttrValue = map(seqC(char("'"), capture(manyTillStr("'"), "v"), char("'")), ({ v }) => `'${v}'`);
+const unquotedAttrValue = many1WithJoin(noneOf(" \t\n\"'=<>`"));
+const htmlAttrValue = or(dqAttrValue, sqAttrValue, unquotedAttrValue);
+/* Optional `= value` suffix on an attribute. Whitespace is allowed on both
+ * sides of the `=` per CommonMark. */
+const htmlAttrEq = map(seqC(capture(htmlWS, "wsBefore"), char("="), capture(htmlWS, "wsAfter"), capture(htmlAttrValue, "v")), ({ wsBefore, wsAfter, v }) => `${wsBefore}=${wsAfter}${v}`);
+const htmlAttribute = map(seqC(capture(htmlAttrName, "name"), capture(optional(htmlAttrEq), "eq")), ({ name, eq }) => name + (eq !== null && eq !== void 0 ? eq : ""));
+/* Zero or more attributes, each separated from the previous token by
+ * at least one whitespace char. Returns the joined source (including the
+ * separating whitespace) so the outer parser can reconstruct the original. */
+const htmlAttributes = manyWithJoin(map(seqC(capture(htmlWS1, "ws"), capture(htmlAttribute, "attr")), ({ ws, attr }) => ws + attr));
+export const htmlOpenTagParser = map(seqC(char("<"), capture(htmlTagName, "name"), capture(htmlAttributes, "attrs"), capture(htmlWS, "ws"), capture(optional(char("/")), "selfClose"), char(">")), ({ name, attrs, ws, selfClose }) => ({
+    type: "inline-html",
+    content: `<${name}${attrs}${ws}${selfClose !== null && selfClose !== void 0 ? selfClose : ""}>`,
+}));
+export const htmlCloseTagParser = map(seqC(str("</"), capture(htmlTagName, "name"), capture(htmlWS, "ws"), char(">")), ({ name, ws }) => ({
+    type: "inline-html",
+    content: `</${name}${ws}>`,
+}));
+/* HTML comments: `<!-- … -->`. CommonMark rules:
+ *   - the body may not contain `--`,
+ *   - the body may not start or end with `>`.
+ *
+ * Expressed as pure combinators by baking the constraints into the body atom:
+ *   - `not(str("-->"))` so we stop cleanly at the closer,
+ *   - `not(str("--"))` rejects a `--` mid-body,
+ *   - `not(seqR(char(">"), str("-->")))` is the "end-of-body `>` " rule —
+ *     a `>` directly before the closer is rejected, since accepting it
+ *     would let the comment end on `>`.
+ *
+ * The start-of-body `>` rule is enforced with one `not(char(">"))` placed
+ * before the body's `many1`. An empty body falls through to `optional`'s
+ * null branch, which leaves the input unconsumed so the closer can match
+ * immediately. */
+const commentBodyChar = map(seqC(not(str("-->")), not(str("--")), not(seqR(char(">"), str("-->"))), capture(anyChar, "c")), ({ c }) => c);
+const commentBody = map(optional(map(seqC(not(char(">")), capture(many1WithJoin(commentBodyChar), "body")), ({ body }) => body)), (body) => body !== null && body !== void 0 ? body : "");
+export const htmlCommentParser = map(seqC(str("<!--"), capture(commentBody, "body"), str("-->")), ({ body }) => ({
+    type: "inline-html",
+    content: `<!--${body}-->`,
+}));
+/* Inline HTML dispatch. `htmlCommentParser` runs first so `<!--…-->` isn't
+ * stolen by `htmlOpenTagParser` (which would otherwise see `<!` and bail).
+ * `htmlCloseTagParser` runs before `htmlOpenTagParser` because the open-tag
+ * parser would accept `<` followed by a tag name and we want `</a>` to win
+ * over an attempted `<` + `/a` (which isn't a valid attribute shape anyway). */
+export const htmlInlineParser = or(htmlCommentParser, htmlCloseTagParser, htmlOpenTagParser);
+// Footnote reference: `[^id]` (id has no `]`, `\n`, or spaces).
+export const inlineFootnoteRefParser = seqC(set("type", "inline-footnote-ref"), str("[^"), capture(many1WithJoin(noneOf("] \n\t")), "id"), char("]"));
+// `[...]` where ... is one or more characters that aren't `]` or newline.
+const bracketed = between(char("["), char("]"), noneOf("]\n"));
+const bracketedAsString = map(bracketed, (chars) => chars.join(""));
+export const inlineRefLinkParser = map(seqC(capture(bracketedAsString, "text"), capture(optional(bracketedAsString), "rawId"), not(char("(")) // disambiguate from inline link
+), ({ text, rawId }) => ({
+    type: "inline-ref-link",
+    text,
+    id: rawId && rawId.length > 0 ? rawId : text,
+}));
+export const inlineRefImageParser = map(seqC(char("!"), capture(bracketedAsString, "alt"), capture(optional(bracketedAsString), "rawId"), not(char("("))), ({ alt, rawId }) => ({
+    type: "inline-ref-image",
+    alt,
+    id: rawId && rawId.length > 0 ? rawId : alt,
+}));
+/** An inline image: ![alt](url) or ![alt](url "title"). Lives in `inline.ts`
+ *  so it can participate in paragraph parsing without `blocks.ts` becoming a
+ *  circular dep. */
+export const imageParser = map(seqC(str("!["), capture(iManyTillStr("]("), "alt"), str("]("), capture(urlToken, "url"), capture(optional(titleClause), "title"), char(")")), ({ alt, url, title }) => {
+    const img = { type: "image", alt, url };
+    if (title != null)
+        img.title = title;
+    return img;
+});
+export const hardBreakParser = map(or(
+// two-or-more trailing spaces then newline
+seqR(str("  "), many(char(" ")), char("\n")), 
+// backslash then newline
+seqR(char("\\"), char("\n"))), () => ({ type: "inline-hard-break" }));
+/** A single `\n` that is *not* part of a blank line (which would terminate the
+ *  enclosing paragraph). Hard breaks are matched earlier in `inlineMarkdownParser`'s
+ *  `or` so a "  \n" stays a hard break, never a soft one. */
+export const softBreakParser = map(seqR(char("\n"), not(char("\n"))), () => ({ type: "inline-soft-break" }));
+export const inlineStrikeParser = map(seqC(str("~~"), capture(inlineSeqUntil(str("~~")), "content"), str("~~")), ({ content }) => ({
+    type: "inline-strike",
+    content: content,
+}));
+/* HTML entities. Decodes:
+ *   - the five XML-core named entities (`&amp;`, `&lt;`, `&gt;`, `&quot;`,
+ *     `&apos;`) into their literal characters,
+ *   - decimal numeric references (`&#NN;`),
+ *   - hexadecimal numeric references (`&#xNN;` / `&#XNN;`).
+ *
+ * Unknown named entities (e.g. `&unknown;`) fail this parser and fall
+ * through to `inlineLiteralCharParser`, which emits a literal `&`. */
+const namedEntity = or(map(str("&amp;"), () => "&"), map(str("&lt;"), () => "<"), map(str("&gt;"), () => ">"), map(str("&quot;"), () => '"'), map(str("&apos;"), () => "'"));
+const decimalEntity = map(seqC(str("&#"), capture(many1WithJoin(digit), "digits"), char(";")), ({ digits }) => String.fromCodePoint(parseInt(digits, 10)));
+const hexEntity = map(seqC(or(str("&#x"), str("&#X")), capture(many1WithJoin(oneOf("0123456789abcdefABCDEF")), "digits"), char(";")), ({ digits }) => String.fromCodePoint(parseInt(digits, 16)));
+export const htmlEntityParser = map(or(hexEntity, decimalEntity, namedEntity), (content) => ({ type: "inline-text", content }));
+/** Last-resort: consume a single delimiter char as literal text so unmatched
+ *  delimiters (e.g. the `_` in snake_case_word, or a stray `*`) don't crash
+ *  the paragraph. Matches one of the inline-text stop characters. */
+export const inlineLiteralCharParser = seqC(set("type", "inline-text"), capture(oneOf("*_`[]!<~\\&"), "content"));
+export const inlineMarkdownParser = or(hardBreakParser, inlineEscapeParser, inlineBoldItalicParser, inlineBoldParser, inlineItalicParser, inlineBoldUnderscoreParser, inlineItalicUnderscoreParser, inlineStrikeParser, autolinkParser, bareUrlAutolinkParser, htmlInlineParser, imageParser, inlineRefImageParser, inlineFootnoteRefParser, inlineLinkParser, inlineRefLinkParser, inlineCodeParser, htmlEntityParser, inlineTextParser, inlineLiteralCharParser);

package/dist/parsers/markdown/references.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from "../../types.js";
+import { LinkDef, FootnoteDef } from "./types.js";
+export declare const linkDefinitionParser: Parser<LinkDef>;
+export declare const footnoteDefinitionParser: Parser<FootnoteDef>;
+export declare function resolveReferences(ast: unknown[]): unknown[];

package/dist/parsers/markdown/references.js

@@ -0,0 +1,96 @@
+import { seqC, capture, optional, many1WithJoin, map, } from "../../combinators.js";
+import { char, str, set, noneOf, spaces } from "../../parsers.js";
+/* Reference link definitions.
+ *
+ *   [id]: url
+ *   [id]: url "title"
+ *
+ * Built entirely from combinators. The optional title is `seqR(spaces, "..."`
+ * unwrapped via `map`. */
+const idChars = many1WithJoin(noneOf("]\n"));
+const urlChars = many1WithJoin(noneOf(" \t\n"));
+const titleChars = many1WithJoin(noneOf('"\n'));
+const titleParser = map(seqC(spaces, char('"'), capture(titleChars, "title"), char('"')), ({ title }) => title);
+export const linkDefinitionParser = seqC(set("type", "link-definition"), char("["), capture(idChars, "id"), str("]:"), spaces, capture(urlChars, "url"), optional(capture(titleParser, "title")));
+/* Footnote definitions: `[^id]: text` on a single line. */
+export const footnoteDefinitionParser = seqC(set("type", "footnote-definition"), str("[^"), capture(many1WithJoin(noneOf("] \n\t")), "id"), str("]:"), spaces, capture(many1WithJoin(noneOf("\n")), "content"));
+/* Resolution pass.
+ *
+ * Walk the AST. Collect link-definitions, then rewrite ref nodes to inline
+ * links/images and strip the definitions. Id matching is case-insensitive. */
+export function resolveReferences(ast) {
+    const linkDefs = new Map();
+    const footnoteDefs = new Map();
+    for (const node of ast) {
+        if (!isObj(node))
+            continue;
+        const t = node.type;
+        if (t === "link-definition") {
+            const def = node;
+            linkDefs.set(def.id.toLowerCase(), def);
+        }
+        else if (t === "footnote-definition") {
+            const def = node;
+            footnoteDefs.set(def.id.toLowerCase(), def);
+        }
+    }
+    function walk(node) {
+        if (Array.isArray(node))
+            return node.map(walk);
+        if (!isObj(node))
+            return node;
+        const obj = node;
+        if (obj.type === "inline-ref-link") {
+            const def = linkDefs.get(String(obj.id).toLowerCase());
+            if (def) {
+                const link = {
+                    type: "inline-link",
+                    content: [{ type: "inline-text", content: String(obj.text) }],
+                    url: def.url,
+                };
+                if (def.title != null)
+                    link.title = def.title;
+                return link;
+            }
+            return { type: "inline-text", content: `[${obj.text}]` };
+        }
+        if (obj.type === "inline-ref-image") {
+            const def = linkDefs.get(String(obj.id).toLowerCase());
+            if (def) {
+                const img = {
+                    type: "image",
+                    url: def.url,
+                    alt: obj.alt,
+                };
+                if (def.title != null)
+                    img.title = def.title;
+                return img;
+            }
+            return { type: "inline-text", content: `![${obj.alt}]` };
+        }
+        if (obj.type === "inline-footnote-ref") {
+            const def = footnoteDefs.get(String(obj.id).toLowerCase());
+            if (def) {
+                return { type: "inline-footnote-ref", id: obj.id, content: def.content };
+            }
+            return { type: "inline-text", content: `[^${obj.id}]` };
+        }
+        // recurse into known child-bearing fields
+        const out = Object.assign({}, obj);
+        for (const key of ["content", "items", "rows"]) {
+            if (Array.isArray(obj[key]))
+                out[key] = obj[key].map(walk);
+        }
+        if (obj.sublist)
+            out.sublist = walk(obj.sublist);
+        return out;
+    }
+    return ast
+        .filter((n) => !(isObj(n) &&
+        (n.type === "link-definition" ||
+            n.type === "footnote-definition")))
+        .map(walk);
+}
+function isObj(v) {
+    return typeof v === "object" && v !== null;
+}

package/dist/parsers/markdown/types.d.ts

@@ -0,0 +1,125 @@
+export type InlineMarkdown = InlineText | InlineSoftBreak | InlineBold | InlineItalic | InlineBoldItalic | InlineStrike | InlineHardBreak | InlineLink | InlineCode | Image | InlineRefLink | InlineRefImage | InlineFootnoteRef | InlineHTML;
+export type InlineHTML = {
+    type: "inline-html";
+    /** Raw passthrough source including angle brackets. */
+    content: string;
+};
+export type InlineText = {
+    type: "inline-text";
+    content: string;
+};
+export type InlineBold = {
+    type: "inline-bold";
+    content: InlineMarkdown[];
+};
+export type InlineItalic = {
+    type: "inline-italic";
+    content: InlineMarkdown[];
+};
+export type InlineBoldItalic = {
+    type: "inline-bold-italic";
+    content: InlineMarkdown[];
+};
+export type InlineStrike = {
+    type: "inline-strike";
+    content: InlineMarkdown[];
+};
+export type InlineHardBreak = {
+    type: "inline-hard-break";
+};
+export type InlineSoftBreak = {
+    type: "inline-soft-break";
+};
+export type InlineLink = {
+    type: "inline-link";
+    content: InlineMarkdown[];
+    url: string;
+    title?: string;
+};
+export type InlineCode = {
+    type: "inline-code";
+    content: string;
+};
+export type Paragraph = {
+    type: "paragraph";
+    content: InlineMarkdown[];
+};
+export type Heading = {
+    type: "heading";
+    level: number;
+    content: InlineMarkdown[];
+};
+export type CodeBlock = {
+    type: "code-block";
+    content: string;
+    language: string | null;
+};
+export type BlockQuoteContent = InlineMarkdown | BlockQuote;
+export type BlockQuote = {
+    type: "block-quote";
+    content: BlockQuoteContent[];
+};
+export type Image = {
+    type: "image";
+    url: string;
+    alt: string;
+    title?: string;
+};
+export type InlineRefLink = {
+    type: "inline-ref-link";
+    text: string;
+    id: string;
+};
+export type InlineRefImage = {
+    type: "inline-ref-image";
+    alt: string;
+    id: string;
+};
+export type ListItem = {
+    content: InlineMarkdown[];
+    sublist?: List;
+    /** GFM task-list state: `true` for `[x]`/`[X]`, `false` for `[ ]`, absent for plain items. */
+    checked?: boolean;
+};
+export type List = {
+    type: "list";
+    ordered: boolean;
+    start: number;
+    items: ListItem[];
+};
+export type HorizontalRule = {
+    type: "horizontal-rule";
+};
+export type Alignment = "left" | "right" | "center" | null;
+export type Table = {
+    type: "table";
+    headers: string[];
+    alignments: Alignment[];
+    rows: string[][];
+};
+export type LinkDef = {
+    type: "link-definition";
+    id: string;
+    url: string;
+    title?: string;
+};
+export type InlineFootnoteRef = {
+    type: "inline-footnote-ref";
+    id: string;
+    /** Filled in by `resolveReferences` when a matching FootnoteDef exists. */
+    content?: string;
+};
+export type FootnoteDef = {
+    type: "footnote-definition";
+    id: string;
+    content: string;
+};
+export type HTMLBlock = {
+    type: "html-block";
+    content: string;
+};
+export type FrontmatterValue = string | number | boolean | null | FrontmatterValue[];
+export type Frontmatter = {
+    type: "frontmatter";
+    data: Record<string, FrontmatterValue>;
+};

package/dist/parsers/markdown/types.js

@@ -0,0 +1,2 @@
+/* AST types for the Markdown example parser. */
+export {};

package/dist/parsers.js

@@ -168,7 +168,23 @@ export const quotedString = trace("quotedString", (input) => {
         recordFailure(input, "a quoted string");
         return failure(`expected a quote, got ${escape(input[0])}`, input);
     }
-    const closeIdx = input.indexOf(q, 1);
+    let closeIdx = -1;
+    let searchFrom = 1;
+    while (true) {
+        const idx = input.indexOf(q, searchFrom);
+        if (idx === -1)
+            break;
+        // Count consecutive backslashes before the quote
+        let backslashes = 0;
+        for (let i = idx - 1; i >= 1 && input[i] === "\\"; i--)
+            backslashes++;
+        if (backslashes % 2 === 0) {
+            // Even number of backslashes (including 0) means the quote is unescaped
+            closeIdx = idx;
+            break;
+        }
+        searchFrom = idx + 1;
+    }
     if (closeIdx === -1) {
         recordFailure(input, "a quoted string");
         return failure(`expected closing ${escape(q)}`, input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsec",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {
@@ -19,6 +19,11 @@
     ".": {
       "import": "./dist/index.js",
       "require": "./dist/index.js"
+    },
+    "./parsers/markdown": {
+      "import": "./dist/parsers/markdown/index.js",
+      "require": "./dist/parsers/markdown/index.js",
+      "types": "./dist/parsers/markdown/index.d.ts"
     }
   },
   "type": "module",
@@ -38,4 +43,4 @@
     "typescript": "^5.4.2",
     "vitest": "^1.4.0"
   }
-}
+}